home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Term / Extras / Source / term-source.lha / XEM.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  23KB  |  1,234 lines
  1. /*
  2. **    XEM.c
  3. **
  4. **    External emulation support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. typedef VOID (*CALLBACK)(VOID);
  17.  
  18. LONG SAVE_DS
  19. xem_sflush(VOID)
  20. {
  21.     return((LONG)FlushSerialRead());
  22. }
  23.  
  24. LONG SAVE_DS
  25. xem_squery(VOID)
  26. {
  27.     if(WriteRequest)
  28.     {
  29.         ULONG    Waiting;
  30.         UWORD    Status;
  31.  
  32.         GetSerialInfo(&Waiting,&Status);
  33.  
  34.             /* Return error if carrier is lost. */
  35.  
  36.         if((Status & CIAF_COMCD) && Config->SerialConfig->CheckCarrier && !Config->SerialConfig->DirectConnection)
  37.             SetOnlineState(FALSE);
  38.         else
  39.             return((LONG)Waiting);
  40.     }
  41.  
  42.     return(-1);
  43. }
  44.  
  45. LONG SAVE_DS ASM
  46. xem_sread(REG(a0) APTR Buffer,REG(d0) LONG Size,REG(d1) ULONG Timeout)
  47. {
  48.     DB(kprintf("xem_sread(0x%08lx,%ld,%ld)\n",Buffer,Size,Timeout));
  49.  
  50.         /* Are both IORequests available? */
  51.  
  52.     if(WriteRequest && ReadRequest)
  53.     {
  54.             /* Valid size parameter? */
  55.  
  56.         if(Size > 0)
  57.         {
  58.             ULONG    Waiting;
  59.             UWORD    Status;
  60.  
  61.             GetSerialInfo(&Waiting,&Status);
  62.  
  63.                 /* Return error if carrier is lost. */
  64.  
  65.             if(Config->SerialConfig->CheckCarrier && !Config->SerialConfig->DirectConnection)
  66.             {
  67.                 if(Status & CIAF_COMCD)
  68.                 {
  69.                     SetOnlineState(FALSE);
  70.  
  71.                     TransferError = TRUE;
  72.  
  73.                     return(-1);
  74.                 }
  75.             }
  76.  
  77.             /* ALWAYS */
  78.             {
  79.                 if(Waiting)
  80.                 {
  81.                         /* No timeout specified? Read as many
  82.                          * bytes as available.
  83.                          */
  84.  
  85.                     if(!Timeout)
  86.                     {
  87.                         if(Waiting > Size)
  88.                             Waiting = Size;
  89.  
  90.                         if(DoSerialRead(Buffer,Waiting))
  91.                             Waiting = ReadRequest->IOSer.io_Actual;
  92.  
  93.                         BytesIn += Waiting;
  94.  
  95.                         return((LONG)Waiting);
  96.                     }
  97.  
  98.                         /* Enough data pending to be read? */
  99.  
  100.                     if(Waiting >= Size)
  101.                     {
  102.                         if(DoSerialRead(Buffer,Size))
  103.                             Size = ReadRequest->IOSer.io_Actual;
  104.  
  105.                         BytesIn += Size;
  106.  
  107.                         return(Size);
  108.                     }
  109.                 }
  110.                 else
  111.                 {
  112.                         /* No timeout & no bytes available:
  113.                          * return immediately.
  114.                          */
  115.  
  116.                     if(!Timeout)
  117.                         return(0);
  118.                 }
  119.             }
  120.  
  121.             /* ALWAYS */
  122.             {
  123.                 ULONG    SignalSet,
  124.                         SerialMask = PORTMASK(ReadPort);
  125.  
  126.                     /* Set up the timer. */
  127.  
  128.                 StartTime(Timeout / MILLION,Timeout % MILLION);
  129.  
  130.                     /* Set up the read request. */
  131.  
  132.                 StartSerialRead(Buffer,Size);
  133.  
  134.                 FOREVER
  135.                 {
  136.                     SignalSet = Wait(SerialMask | SIG_TIMER);
  137.  
  138.                         /* Receive buffer filled? */
  139.  
  140.                     if(SignalSet & SerialMask)
  141.                     {
  142.                             /* Abort the timer request. */
  143.  
  144.                         StopTime();
  145.  
  146.                             /* Did the request terminate gracefully? */
  147.  
  148.                         if(WaitSerialRead())
  149.                             Size = ReadRequest->IOSer.io_Actual;
  150.  
  151.                         BytesIn += Size;
  152.  
  153.                         return(Size);
  154.                     }
  155.  
  156.                         /* Hit by timeout? */
  157.  
  158.                     if(SignalSet & SIG_TIMER)
  159.                     {
  160.                             /* Abort the read request. */
  161.  
  162.                         StopSerialRead();
  163.  
  164.                             /* Remove the timer request. */
  165.  
  166.                         WaitTime();
  167.  
  168.                             /* Did the driver receive any
  169.                              * data?
  170.                              */
  171.  
  172.                         if(ReadRequest->IOSer.io_Actual)
  173.                         {
  174.                             BytesIn += ReadRequest->IOSer.io_Actual;
  175.  
  176.                             return((LONG)ReadRequest->IOSer.io_Actual);
  177.                         }
  178.                         else
  179.                         {
  180.                                 /* Take a second look and query the number of
  181.                                  * bytes ready to be received, there may
  182.                                  * still be some bytes in the buffer.
  183.                                  * Note: this depends on the way the
  184.                                  * driver handles read abort.
  185.                                  */
  186.  
  187.                             Waiting = GetSerialWaiting();
  188.  
  189.                                 /* Don't read too much. */
  190.  
  191.                             if(Size > Waiting)
  192.                                 Size = Waiting;
  193.  
  194.                                 /* Are there any bytes to be transferred? */
  195.  
  196.                             if(Size)
  197.                             {
  198.                                     /* Read the data. */
  199.  
  200.                                 if(DoSerialRead(Buffer,Size))
  201.                                     Size = ReadRequest->IOSer.io_Actual;
  202.  
  203.                                 BytesIn += Size;
  204.                             }
  205.  
  206.                             return(Size);
  207.                         }
  208.                     }
  209.                 }
  210.             }
  211.         }
  212.         else
  213.             return(0);
  214.     }
  215.     else
  216.         return(-1);
  217. }
  218.  
  219. ULONG SAVE_DS ASM
  220. xem_toptions(REG(d0) LONG NumOpts,REG(a0) struct xem_option **Opts)
  221. {
  222.     if(NumOpts && Opts)
  223.     {
  224.         enum    {    GAD_USE=1,GAD_CANCEL,GAD_SPECIAL };
  225.  
  226.         LayoutHandle    *Handle;
  227.         ULONG             Flags = NULL;
  228.  
  229.             /* We only have 32 bits! */
  230.  
  231.         if(NumOpts > 32)
  232.             NumOpts = 32;
  233.  
  234.         if(Handle = LT_CreateHandleTags(Window->WScreen,
  235.             LAHN_LocaleHook,    &LocaleHook,
  236.         TAG_DONE))
  237.         {
  238.             struct Window    *PanelWindow;
  239.             LONG             i,Split;
  240.  
  241.             if(NumOpts > 16)
  242.                 Split = NumOpts / 2;
  243.             else
  244.                 Split = -1;
  245.  
  246.             LT_New(Handle,
  247.                 LA_Type,VERTICAL_KIND,
  248.             TAG_DONE);
  249.             {
  250.                 LT_New(Handle,
  251.                     LA_Type,HORIZONTAL_KIND,
  252.                 TAG_DONE);
  253.                 {
  254.                     LT_New(Handle,
  255.                         LA_Type,VERTICAL_KIND,
  256.                     TAG_DONE);
  257.                     {
  258.                         for(i = 0 ; i < NumOpts ; i++)
  259.                         {
  260.                             if(Opts[i])
  261.                             {
  262.                                 switch(Opts[i]->xemo_type)
  263.                                 {
  264.                                     case XEMO_BOOLEAN:
  265.  
  266.                                         LT_New(Handle,
  267.                                             LA_Type,        CHECKBOX_KIND,
  268.                                             LA_LabelText,    Opts[i]->xemo_description,
  269.                                             LA_ID,            GAD_SPECIAL + i,
  270.                                             GTCB_Checked,    String2Boolean(Opts[i]->xemo_value),
  271.                                         TAG_DONE);
  272.  
  273.                                         break;
  274.  
  275.                                     case XEMO_LONG:
  276.  
  277.                                         LT_New(Handle,
  278.                                             LA_Type,                INTEGER_KIND,
  279.                                             LA_LabelText,            Opts[i]->xemo_description,
  280.                                             LA_ID,                    GAD_SPECIAL + i,
  281.                                             LA_Chars,                15,
  282.                                             GTIN_Number,            Atol(Opts[i]->xemo_value),
  283.                                             LAIN_UseIncrementers,    TRUE,
  284.                                         TAG_DONE);
  285.  
  286.                                         break;
  287.  
  288.                                     case XEMO_STRING:
  289.  
  290.                                         LT_New(Handle,
  291.                                             LA_Type,        STRING_KIND,
  292.                                             LA_LabelText,    Opts[i]->xemo_description,
  293.                                             LA_ID,            GAD_SPECIAL + i,
  294.                                             LA_Chars,        15,
  295.                                             GTST_String,    Opts[i]->xemo_value,
  296.                                             GTST_MaxChars,    Opts[i]->xemo_length - 1,
  297.                                         TAG_DONE);
  298.  
  299.                                         break;
  300.  
  301.                                     case XEMO_COMMPAR:
  302.  
  303.                                         LT_New(Handle,
  304.                                             LA_Type,        STRING_KIND,
  305.                                             LA_LabelText,    Opts[i]->xemo_description,
  306.                                             LA_ID,            GAD_SPECIAL + i,
  307.                                             LA_Chars,        15,
  308.                                             LA_HighLabel,    TRUE,
  309.                                             GTST_String,    Opts[i]->xemo_value,
  310.                                             GTST_MaxChars,    Opts[i]->xemo_length - 1,
  311.                                         TAG_DONE);
  312.  
  313.                                         break;
  314.  
  315.                                     case XEMO_HEADER:
  316.  
  317.                                         LT_New(Handle,
  318.                                             LA_Type,        TEXT_KIND,
  319.                                             LA_LabelText,    Opts[i]->xemo_description,
  320.                                             LA_HighLabel,    TRUE,
  321.                                             GTTX_Text,        " ",
  322.                                         TAG_DONE);
  323.  
  324.                                         break;
  325.  
  326.                                     case XEMO_COMMAND:
  327.  
  328.                                         LT_New(Handle,
  329.                                             LA_Type,        BUTTON_KIND,
  330.                                             LA_LabelText,    Opts[i]->xemo_description,
  331.                                             LA_ID,            GAD_SPECIAL + i,
  332.                                             LA_Chars,        15,
  333.                                         TAG_DONE);
  334.  
  335.                                         break;
  336.                                 }
  337.                             }
  338.  
  339.                             if(i == Split)
  340.                             {
  341.                                 LT_EndGroup(Handle);
  342.  
  343.                                 LT_New(Handle,
  344.                                     LA_Type,VERTICAL_KIND,
  345.                                 TAG_DONE);
  346.                                 {
  347.                                     LT_New(Handle,
  348.                                         LA_Type,YBAR_KIND,
  349.                                     TAG_DONE);
  350.  
  351.                                     LT_EndGroup(Handle);
  352.                                 }
  353.  
  354.                                 LT_New(Handle,
  355.                                     LA_Type,VERTICAL_KIND,
  356.                                 TAG_DONE);
  357.                             }
  358.                         }
  359.  
  360.                         LT_EndGroup(Handle);
  361.                     }
  362.  
  363.                     LT_EndGroup(Handle);
  364.                 }
  365.  
  366.                 LT_New(Handle,
  367.                     LA_Type,VERTICAL_KIND,
  368.                 TAG_DONE);
  369.                 {
  370.                     LT_New(Handle,
  371.                         LA_Type,        XBAR_KIND,
  372.                         LAXB_FullSize,    TRUE,
  373.                     TAG_DONE);
  374.  
  375.                     LT_EndGroup(Handle);
  376.                 }
  377.  
  378.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  379.                     LAGR_SameSize,    TRUE,
  380.                     LAGR_Spread,    TRUE,
  381.                 TAG_DONE);
  382.                 {
  383.                     LT_New(Handle,
  384.                         LA_Type,        BUTTON_KIND,
  385.                         LA_LabelID,        MSG_GLOBAL_SAVE_TXT,
  386.                         LA_ID,            GAD_USE,
  387.                         LABT_ReturnKey,    TRUE,
  388.                         LABT_ExtraFat,    TRUE,
  389.                     TAG_DONE);
  390.  
  391.                     LT_New(Handle,
  392.                         LA_Type,        BUTTON_KIND,
  393.                         LA_LabelID,        MSG_GLOBAL_CANCEL_GAD,
  394.                         LA_ID,            GAD_CANCEL,
  395.                         LABT_EscKey,    TRUE,
  396.                         LABT_ExtraFat,    TRUE,
  397.                     TAG_DONE);
  398.  
  399.                     LT_EndGroup(Handle);
  400.                 }
  401.  
  402.                 LT_EndGroup(Handle);
  403.             }
  404.  
  405.             if(PanelWindow = LT_Build(Handle,
  406.                 LAWN_TitleText,        OptionTitle ? OptionTitle : LocaleString(MSG_V36_1840),
  407.                 LAWN_HelpHook,        &GuideHook,
  408.                 LAWN_Parent,        Window,
  409.                 WA_DepthGadget,        TRUE,
  410.                 WA_DragBar,            TRUE,
  411.                 WA_RMBTrap,            TRUE,
  412.                 WA_Activate,        TRUE,
  413.                 WA_SimpleRefresh,    TRUE,
  414.             TAG_DONE))
  415.             {
  416.                 struct IntuiMessage    *Message;
  417.                 BOOL                 Done = FALSE;
  418.                 ULONG                 MsgClass;
  419.                 UWORD                 MsgCode;
  420.                 struct Gadget        *MsgGadget;
  421.                 BOOL                 CheckFlags = FALSE;
  422.  
  423.                 PushWindow(PanelWindow);
  424.  
  425.                 LT_ShowWindow(Handle,TRUE);
  426.  
  427.                 do
  428.                 {
  429.                     if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  430.                         break;
  431.  
  432.                     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  433.                     {
  434.                         MsgClass    = Message->Class;
  435.                         MsgCode        = Message->Code;
  436.                         MsgGadget    = (struct Gadget *)Message->IAddress;
  437.  
  438.                         LT_ReplyIMsg(Message);
  439.  
  440.                         if(MsgClass == IDCMP_GADGETUP)
  441.                         {
  442.                             switch(MsgGadget->GadgetID)
  443.                             {
  444.                                 case GAD_USE:
  445.  
  446.                                     LT_UpdateStrings(Handle);
  447.  
  448.                                     Done = CheckFlags = TRUE;
  449.                                     break;
  450.  
  451.                                 case GAD_CANCEL:
  452.  
  453.                                     Done = TRUE;
  454.                                     break;
  455.  
  456.                                 default:
  457.  
  458.                                     if(MsgGadget->GadgetID - GAD_SPECIAL < NumOpts)
  459.                                     {
  460.                                         i = MsgGadget->GadgetID - GAD_SPECIAL;
  461.  
  462.                                         if(Opts[i]->xemo_type == XEMO_COMMAND || (Opts[i]->xemo_type == XEMO_COMMPAR && MsgCode != '\t'))
  463.                                         {
  464.                                             Flags = (1L << i);
  465.  
  466.                                             Done = CheckFlags = TRUE;
  467.                                         }
  468.                                     }
  469.  
  470.                                     break;
  471.                             }
  472.                         }
  473.                     }
  474.                 }
  475.                 while(!Done);
  476.  
  477.                 PopWindow();
  478.  
  479.                 if(CheckFlags)
  480.                 {
  481.                     STRPTR String;
  482.  
  483.                     LT_LockWindow(PanelWindow);
  484.  
  485.                     for(i = 0 ; i < NumOpts ; i++)
  486.                     {
  487.                         if(Opts[i])
  488.                         {
  489.                             switch(Opts[i]->xemo_type)
  490.                             {
  491.                                 case XEMO_BOOLEAN:
  492.  
  493.                                     if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE) != String2Boolean(Opts[i]->xemo_value))
  494.                                     {
  495.                                         Flags |= (1L << i);
  496.  
  497.                                         if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  498.                                             strcpy(Opts[i]->xemo_value,"yes");
  499.                                         else
  500.                                             strcpy(Opts[i]->xemo_value,"no");
  501.  
  502.                                         NewOptions = TRUE;
  503.                                     }
  504.  
  505.                                     break;
  506.  
  507.                                 case XEMO_LONG:
  508.  
  509.                                     if(Atol(Opts[i]->xemo_value) != LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  510.                                     {
  511.                                         Flags |= (1L << i);
  512.  
  513.                                         SPrintf(Opts[i]->xemo_value,"%ld",LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE));
  514.  
  515.                                         NewOptions = TRUE;
  516.                                     }
  517.  
  518.                                     break;
  519.  
  520.                                 case XEMO_COMMPAR:
  521.                                 case XEMO_STRING:
  522.  
  523.                                     if(String = LT_GetString(Handle,GAD_SPECIAL + i))
  524.                                     {
  525.                                         if(strcmp(Opts[i]->xemo_value,String))
  526.                                         {
  527.                                             Flags |= (1L << i);
  528.  
  529.                                             strcpy(Opts[i]->xemo_value,LT_GetString(Handle,GAD_SPECIAL + i));
  530.  
  531.                                             NewOptions = TRUE;
  532.                                         }
  533.                                     }
  534.  
  535.                                     break;
  536.                             }
  537.                         }
  538.                     }
  539.  
  540.                     LT_UnlockWindow(PanelWindow);
  541.                 }
  542.                 else
  543.                     Flags = NULL;
  544.             }
  545.  
  546.             LT_DeleteHandle(Handle);
  547.         }
  548.  
  549.         return(Flags);
  550.     }
  551.     else
  552.         return(NULL);
  553. }
  554.  
  555.     /* xem_swrite():
  556.      *
  557.      *    Send a few bytes across the serial line.
  558.      */
  559.  
  560. LONG SAVE_DS ASM
  561. xem_swrite(REG(a0) STRPTR Buffer,REG(d0) LONG Size)
  562. {
  563.     if(WriteRequest)
  564.     {
  565.         SerWrite(Buffer,Size);
  566.  
  567.         return(0);
  568.     }
  569.     else
  570.         return(-1);
  571. }
  572.  
  573.     /* xem_sbreak():
  574.      *
  575.      *    Send a break signal across the serial line.
  576.      */
  577.  
  578. LONG SAVE_DS
  579. xem_sbreak(VOID)
  580. {
  581.     if(!WriteRequest)
  582.         return(-1);
  583.     else
  584.     {
  585.         SendBreak();
  586.  
  587.         return(0);
  588.     }
  589. }
  590.  
  591.     /* xem_sstart():
  592.      *
  593.      *    Restart serial read activity.
  594.      */
  595.  
  596. VOID SAVE_DS
  597. xem_sstart(VOID)
  598. {
  599.     RestartSerial();
  600. }
  601.  
  602.     /* xem_sstop():
  603.      *
  604.      *    Stop serial read activity.
  605.      */
  606.  
  607. LONG SAVE_DS
  608. xem_sstop(VOID)
  609. {
  610.     ClearSerial();
  611.  
  612.     return(0);
  613. }
  614.  
  615.     /* xem_tgets(STRPTR Prompt,STRPTR Buffer,ULONG Size):
  616.      *
  617.      *    Get a string from the user.
  618.      */
  619.  
  620. LONG SAVE_DS ASM
  621. xem_tgets(REG(a0) STRPTR Prompt,REG(a1) STRPTR Buffer,REG(d0) ULONG Size)
  622. {
  623.     enum    {    GAD_Use=1,GAD_Cancel,GAD_String };
  624.  
  625.     LayoutHandle    *Handle;
  626.     LONG             Success = FALSE;
  627.     UBYTE             LocalBuffer[256];
  628.  
  629.     if(strlen(Buffer) > sizeof(LocalBuffer) - 1)
  630.     {
  631.         CopyMem(Buffer,LocalBuffer,sizeof(LocalBuffer) - 1);
  632.  
  633.         LocalBuffer[sizeof(LocalBuffer) - 1] = 0;
  634.     }
  635.     else
  636.         strcpy(LocalBuffer,Buffer);
  637.  
  638.     if(!Prompt)
  639.         Prompt = LocaleString(MSG_TERMXPR_INPUT_REQUIRED_TXT);
  640.  
  641.     if(Handle = LT_CreateHandleTags(Window->WScreen,
  642.         LAHN_LocaleHook,    &LocaleHook,
  643.     TAG_DONE))
  644.     {
  645.         struct Window *PanelWindow;
  646.  
  647.         LT_New(Handle,
  648.             LA_Type,VERTICAL_KIND,
  649.         TAG_DONE);
  650.         {
  651.             LT_New(Handle,
  652.                 LA_Type,        VERTICAL_KIND,
  653.                 LA_LabelText,    Prompt,
  654.             TAG_DONE);
  655.             {
  656.                 LT_New(Handle,
  657.                     LA_Type,        STRING_KIND,
  658.                     LA_STRPTR,        LocalBuffer,
  659.                     LA_Chars,        30,
  660.                     GTST_MaxChars,    Size,
  661.                 TAG_DONE);
  662.  
  663.                 LT_EndGroup(Handle);
  664.             }
  665.  
  666.             LT_New(Handle,
  667.                 LA_Type,VERTICAL_KIND,
  668.             TAG_DONE);
  669.             {
  670.                 LT_New(Handle,
  671.                     LA_Type,        XBAR_KIND,
  672.                     LAXB_FullSize,    TRUE,
  673.                 TAG_DONE);
  674.  
  675.                 LT_EndGroup(Handle);
  676.             }
  677.  
  678.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  679.                 LAGR_SameSize,    TRUE,
  680.                 LAGR_Spread,    TRUE,
  681.             TAG_DONE);
  682.             {
  683.                 LT_New(Handle,
  684.                     LA_Type,        BUTTON_KIND,
  685.                     LA_LabelID,        MSG_TERMXPR_OKAY_GAD,
  686.                     LA_ID,            GAD_Use,
  687.                     LABT_ReturnKey,    TRUE,
  688.                     LABT_ExtraFat,    TRUE,
  689.                 TAG_DONE);
  690.  
  691.                 LT_New(Handle,
  692.                     LA_Type,        BUTTON_KIND,
  693.                     LA_LabelID,        MSG_GLOBAL_CANCEL_GAD,
  694.                     LA_ID,            GAD_Cancel,
  695.                     LABT_EscKey,    TRUE,
  696.                     LABT_ExtraFat,    TRUE,
  697.                 TAG_DONE);
  698.  
  699.                 LT_EndGroup(Handle);
  700.             }
  701.         }
  702.  
  703.         if(PanelWindow = LT_Build(Handle,
  704.             LAWN_TitleID,        MSG_GLOBAL_ENTER_TEXT_TXT,
  705.             LAWN_HelpHook,        &GuideHook,
  706.             LAWN_Parent,        Window,
  707.             WA_DepthGadget,        TRUE,
  708.             WA_DragBar,            TRUE,
  709.             WA_RMBTrap,            TRUE,
  710.             WA_Activate,        TRUE,
  711.             WA_SimpleRefresh,    TRUE,
  712.         TAG_DONE))
  713.         {
  714.             struct IntuiMessage    *Message;
  715.             BOOL                 Done = FALSE;
  716.             ULONG                 MsgClass;
  717.             UWORD                 MsgCode;
  718.             struct Gadget        *MsgGadget;
  719.  
  720.             PushWindow(PanelWindow);
  721.  
  722.             LT_ShowWindow(Handle,TRUE);
  723.  
  724.             LT_Activate(Handle,GAD_String);
  725.  
  726.             do
  727.             {
  728.                 if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  729.                     break;
  730.  
  731.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  732.                 {
  733.                     MsgClass    = Message->Class;
  734.                     MsgCode        = Message->Code;
  735.                     MsgGadget    = (struct Gadget *)Message->IAddress;
  736.  
  737.                     LT_ReplyIMsg(Message);
  738.  
  739.                     if(MsgClass == IDCMP_GADGETUP)
  740.                     {
  741.                         switch(MsgGadget->GadgetID)
  742.                         {
  743.                             case GAD_String:
  744.  
  745.                                 if(MsgCode == '\r')
  746.                                 {
  747.                                     strcpy(Buffer,LocalBuffer);
  748.  
  749.                                     Success = Done = TRUE;
  750.  
  751.                                     LT_PressButton(Handle,GAD_Use);
  752.                                 }
  753.  
  754.                                 break;
  755.  
  756.                             case GAD_Use:
  757.  
  758.                                 strcpy(Buffer,LocalBuffer);
  759.  
  760.                                 Success = Done = TRUE;
  761.                                 break;
  762.  
  763.                             case GAD_Cancel:
  764.  
  765.                                 Done = TRUE;
  766.                                 break;
  767.                         }
  768.                     }
  769.                 }
  770.             }
  771.             while(!Done);
  772.  
  773.             PopWindow();
  774.         }
  775.  
  776.         LT_DeleteHandle(Handle);
  777.     }
  778.  
  779.     return(Success);
  780. }
  781.  
  782.     /* xem_tbeep(ULONG Times,ULONG Delay):
  783.      *
  784.      *    Beep the terminal display.
  785.      */
  786.  
  787. VOID SAVE_DS ASM
  788. xem_tbeep(REG(d0) ULONG Times,REG(d1) ULONG UnusedDelay)    /* ZZZ: what does delay do? */
  789. {
  790.     LONG i;
  791.  
  792.     for(i = 0 ; i < Times ; i++)
  793.     {
  794.             /* Handle the visual part. */
  795.  
  796.         if(Config->TerminalConfig->BellMode != BELL_AUDIBLE)
  797.         {
  798.             if(StatusProcess)
  799.                 Signal((struct Task *)StatusProcess,SIG_BELL);
  800.         }
  801.  
  802.             /* Let it beep. */
  803.  
  804.         if(Config->TerminalConfig->BellMode == BELL_AUDIBLE || Config->TerminalConfig->BellMode == BELL_BOTH)
  805.             SoundPlay(SOUND_BELL);
  806.     }
  807. }
  808.  
  809.     /* xem_macrodispatch(struct XEmulatorMacroKey *XEM_MacroKey):
  810.      *
  811.      *    Dispatch a macro key call.
  812.      */
  813.  
  814. LONG SAVE_DS ASM
  815. xem_macrodispatch(REG(a0) struct XEmulatorMacroKey *XEM_MacroKey)
  816. {
  817.     CALLBACK Routine;
  818.  
  819.         /* If a routine to call is available (most likely xON or xOFF),
  820.          * make a call to it, else process the macro key data.
  821.          */
  822.  
  823.     if(Routine = (CALLBACK)XEM_MacroKey->xmk_UserData)
  824.         (*Routine)();
  825.     else
  826.         SerialCommand(MacroKeys->Keys[XEM_MacroKey->xmk_Qualifier][XEM_MacroKey->xmk_Code - 0x50]);
  827.  
  828.     return(0);
  829. }
  830.  
  831.     /* SetEmulatorOptions(BYTE Mode):
  832.      *
  833.      *    Save or load the emulator options.
  834.      */
  835.  
  836. BOOL
  837. SetEmulatorOptions(LONG Mode)
  838. {
  839.     BOOL Success = FALSE;
  840.  
  841.         /* Is the library available and running? */
  842.  
  843.     if(XEmulatorBase && XEM_IO)
  844.     {
  845.             /* Are we using the new library code? */
  846.  
  847.         if(XEmulatorBase->lib_Version >= 4)
  848.         {
  849.             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  850.  
  851.                 /* Get the name of the library. */
  852.  
  853.             strcpy(LocalBuffer,FilePart(XEmulatorBase->lib_Node.ln_Name));
  854.  
  855.                 /* Does it have any name? */
  856.  
  857.             if(LocalBuffer[0])
  858.             {
  859.                 UBYTE    OtherBuffer[50];
  860.                 LONG    i;
  861.  
  862.                     /* Strip the `.library' bit. */
  863.  
  864.                 for(i = strlen(LocalBuffer) - 1 ; i >= 0 ; i--)
  865.                 {
  866.                     if(LocalBuffer[i] == '.')
  867.                     {
  868.                         LocalBuffer[i] = 0;
  869.  
  870.                         break;
  871.                     }
  872.                 }
  873.  
  874.                     /* What are we to do? */
  875.  
  876.                 if(Mode == XEM_PREFS_LOAD)
  877.                 {
  878.                         /* Restore settings... */
  879.  
  880.                     strcpy(OtherBuffer,"ENV:");
  881.  
  882.                     if(AddPart(OtherBuffer,LocalBuffer,50))
  883.                     {
  884.                             /* If we can't load them,
  885.                              * reset to defaults.
  886.                              */
  887.  
  888.                         if(!XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  889.                         {
  890.                             strcpy(OtherBuffer,"ENV:xem");
  891.  
  892.                             if(AddPart(OtherBuffer,LocalBuffer,50))
  893.                             {
  894.                                 if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  895.                                     Success = TRUE;
  896.                             }
  897.                         }
  898.                         else
  899.                             Success = TRUE;
  900.  
  901.                         if(!Success)
  902.                             XEmulatorPreferences(XEM_IO,NULL,XEM_PREFS_RESET);
  903.                     }
  904.                 }
  905.                 else
  906.                 {
  907.                         /* Save settings to ENV: */
  908.  
  909.                     strcpy(OtherBuffer,"ENV:");
  910.  
  911.                     if(AddPart(OtherBuffer,LocalBuffer,50))
  912.                     {
  913.                         if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  914.                             Success = TRUE;
  915.                     }
  916.  
  917.                     if(Success)
  918.                     {
  919.                         Success = FALSE;
  920.  
  921.                             /* Save settings to ENVARC: */
  922.  
  923.                         strcpy(OtherBuffer,"ENVARC:");
  924.  
  925.                         if(AddPart(OtherBuffer,LocalBuffer,50))
  926.                         {
  927.                             if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  928.                                 Success = TRUE;
  929.                         }
  930.                     }
  931.                 }
  932.             }
  933.         }
  934.     }
  935.  
  936.         /* Return result. */
  937.  
  938.     return(Success);
  939. }
  940.  
  941.     /* SetupEmulator(BOOL OpenConsole):
  942.      *
  943.      *    Initialize the XEM_IO structure.
  944.      */
  945.  
  946. STATIC BOOL
  947. SetupEmulator(VOID)
  948. {
  949.     if(!XEM_IO)
  950.     {
  951.         if(XEM_IO = (struct XEM_IO *)AllocVec(sizeof(struct XEM_IO),MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC))
  952.         {
  953.             XEM_IO->xem_window                = Window;
  954.             XEM_IO->xem_font                = CurrentFont;
  955.             XEM_IO->xem_signal                = &XEM_Signal;
  956.             XEM_IO->xem_screendepth            = GetBitMapDepth(Window->WScreen->RastPort.BitMap);
  957.  
  958. #ifdef USE_GLUE
  959.             XEM_IO->xem_sread                = xem_sread_glue;
  960.             XEM_IO->xem_swrite                = xem_swrite_glue;
  961.             XEM_IO->xem_sflush                = xem_sflush;
  962.             XEM_IO->xem_sbreak                = xem_sbreak;
  963.             XEM_IO->xem_squery                = xem_squery;
  964.             XEM_IO->xem_sstart                = xem_sstart;
  965.             XEM_IO->xem_sstop                = xem_sstop;
  966.             XEM_IO->xem_tbeep                = xem_tbeep_glue;
  967.             XEM_IO->xem_tgets                = xem_tgets_glue;
  968.             XEM_IO->xem_toptions            = xem_toptions_glue;
  969.             XEM_IO->xem_process_macrokeys    = xem_macrodispatch_glue;
  970. #else
  971.             XEM_IO->xem_sread                = xem_sread;
  972.             XEM_IO->xem_swrite                = xem_swrite;
  973.             XEM_IO->xem_sflush                = xem_sflush;
  974.             XEM_IO->xem_sbreak                = xem_sbreak;
  975.             XEM_IO->xem_squery                = xem_squery;
  976.             XEM_IO->xem_sstart                = xem_sstart;
  977.             XEM_IO->xem_sstop                = xem_sstop;
  978.             XEM_IO->xem_tbeep                = xem_tbeep;
  979.             XEM_IO->xem_tgets                = xem_tgets;
  980.             XEM_IO->xem_toptions            = xem_toptions;
  981.             XEM_IO->xem_process_macrokeys    = xem_macrodispatch;
  982. #endif    /* USE_GLUE */
  983.  
  984.             return(TRUE);
  985.         }
  986.     }
  987.  
  988.     return(FALSE);
  989. }
  990.  
  991.     /* CloseEmulator():
  992.      *
  993.      *    Close the emulation library.
  994.      */
  995.  
  996. VOID
  997. CloseEmulator(BOOL Exit)
  998. {
  999.     if(XEmulatorBase)
  1000.     {
  1001.         if(XEM_IO)
  1002.         {
  1003.             XEmulatorMacroKeyFilter(XEM_IO,NULL);
  1004.             XEmulatorCloseConsole(XEM_IO);
  1005.             XEmulatorCleanup(XEM_IO);
  1006.  
  1007.             FreeVec(XEM_IO);
  1008.             XEM_IO = NULL;
  1009.         }
  1010.  
  1011.         CloseLibrary(XEmulatorBase);
  1012.         XEmulatorBase = NULL;
  1013.  
  1014.         WindowJob = SingleWindowJob;
  1015.         UpdateJobMask(MainJobQueue,XEMJob,NULL);
  1016.  
  1017.         if(!Exit)
  1018.         {
  1019.             XEM_Signal = NULL;
  1020.  
  1021.             strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1022.  
  1023.             RasterEnabled = TRUE;
  1024.  
  1025.             ClearCursor();
  1026.  
  1027.             Reset();
  1028.  
  1029.             DrawCursor();
  1030.         }
  1031.     }
  1032. }
  1033.  
  1034.     /* OpenEmulator(STRPTR Name):
  1035.      *
  1036.      *    Open an emulation library.
  1037.      */
  1038.  
  1039. BOOL
  1040. OpenEmulator(STRPTR Name)
  1041. {
  1042.     CloseEmulator(FALSE);
  1043.  
  1044.     XEM_HostData.Source            = NULL;
  1045.     XEM_HostData.Destination    = NULL;
  1046.     XEM_HostData.InESC            = FALSE;
  1047.     XEM_HostData.InCSI            = FALSE;
  1048.  
  1049.     if(XEmulatorBase = OpenLibrary(Name,0))
  1050.     {
  1051.         ClearCursor();
  1052.  
  1053.         Reset();
  1054.  
  1055.         if(SetupEmulator())
  1056.         {
  1057.             BOOL Success;
  1058.  
  1059.             SetMask(RPort,DepthMask);
  1060.  
  1061.             ClearSerial();
  1062.             Success = XEmulatorSetup(XEM_IO);
  1063.             RestartSerial();
  1064.  
  1065.             if(Success)
  1066.             {
  1067.                 SetEmulatorOptions(XEM_PREFS_LOAD);
  1068.  
  1069.                 if(XEmulatorOpenConsole(XEM_IO))
  1070.                 {
  1071.                     STRPTR LibName = FilePart(XEmulatorBase->lib_Node.ln_Name);
  1072.  
  1073.                     strcpy(EmulationName,&LibName[3]);
  1074.  
  1075.                     EmulationName[strlen(EmulationName) - 8] = 0;
  1076.  
  1077.                     SetupXEM_MacroKeys(MacroKeys);
  1078.  
  1079.                     if(XEM_Signal == PORTMASK(Window->UserPort))
  1080.                         WindowJob = WindowAndXEMJob;
  1081.                     else
  1082.                     {
  1083.                         WindowJob = SingleWindowJob;
  1084.                         UpdateJobMask(MainJobQueue,XEMJob,XEM_Signal);
  1085.                     }
  1086.  
  1087.                     return(TRUE);
  1088.                 }
  1089.             }
  1090.         }
  1091.  
  1092.         DrawCursor();
  1093.  
  1094.         CloseLibrary(XEmulatorBase);
  1095.         XEmulatorBase = NULL;
  1096.     }
  1097.  
  1098.     XEM_Signal = NULL;
  1099.  
  1100.     strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1101.  
  1102.     WindowJob = SingleWindowJob;
  1103.     UpdateJobMask(MainJobQueue,XEMJob,NULL);
  1104.  
  1105.     return(FALSE);
  1106. }
  1107.  
  1108.     /* xOn():
  1109.      *
  1110.      *    Small local routine, complements XOff().
  1111.      */
  1112.  
  1113. STATIC VOID
  1114. xOn(VOID)
  1115. {
  1116.     Clear_xOFF();
  1117.  
  1118.     if(Config->SerialConfig->PassThrough)
  1119.     {
  1120.         UBYTE c = XON;
  1121.         SerWrite(&c,1);
  1122.     }
  1123. }
  1124.  
  1125.     /* xOff():
  1126.      *
  1127.      *    Small local routine, complements XOn().
  1128.      */
  1129.  
  1130. STATIC VOID
  1131. xOff(VOID)
  1132. {
  1133.     Set_xOFF();
  1134.  
  1135.     if(Config->SerialConfig->PassThrough)
  1136.     {
  1137.         UBYTE c = XOF;
  1138.         SerWrite(&c,1);
  1139.     }
  1140. }
  1141.  
  1142.     /* SetupXEM_MacroKeys(struct MacroKeys *Keys):
  1143.      *
  1144.      *    Sets up the internal representation of the macro key
  1145.      *    data to fit the XEM specification.
  1146.      */
  1147.  
  1148. VOID
  1149. SetupXEM_MacroKeys(struct MacroKeys *Keys)
  1150. {
  1151.         /* Are we allowed to do what we want to do? */
  1152.  
  1153.     if(XEM_MacroKeys && XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1154.     {
  1155.         LONG i,j,k = 0;
  1156.  
  1157.             /* Run down the list of qualifiers. */
  1158.  
  1159.         for(i = XMKQ_NONE ; i <= XMKQ_CONTROL ; i++)
  1160.         {
  1161.                 /* Run down the function keys. */
  1162.  
  1163.             for(j = 0 ; j < 10 ; j++)
  1164.             {
  1165.                     /* If the key has no data attached,
  1166.                      * don't use it in the list.
  1167.                      */
  1168.  
  1169.                 if(Keys->Keys[i][j][0])
  1170.                 {
  1171.                     XEM_MacroKeys[k].xmk_Type        = XMKT_RAWKEY;
  1172.                     XEM_MacroKeys[k].xmk_Qualifier    = i;
  1173.                     XEM_MacroKeys[k].xmk_Code        = 0x50 + j;
  1174.                     XEM_MacroKeys[k].xmk_UserData    = NULL;
  1175.  
  1176.                     AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1177.                 }
  1178.             }
  1179.         }
  1180.  
  1181.             /* Take care of the rest, add support for the xON key. */
  1182.  
  1183.         XEM_MacroKeys[k].xmk_Type         = XMKT_COOKED;
  1184.         XEM_MacroKeys[k].xmk_Qualifier    = NULL;
  1185.         XEM_MacroKeys[k].xmk_Code        = XON;
  1186.         XEM_MacroKeys[k].xmk_UserData    = (APTR)xOn;
  1187.  
  1188.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1189.  
  1190.             /* Take care of the xOFF key. */
  1191.  
  1192.         XEM_MacroKeys[k].xmk_Type         = XMKT_COOKED;
  1193.         XEM_MacroKeys[k].xmk_Qualifier    = NULL;
  1194.         XEM_MacroKeys[k].xmk_Code        = XOF;
  1195.         XEM_MacroKeys[k].xmk_UserData    = (APTR)xOff;
  1196.  
  1197.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k]);
  1198.  
  1199.             /* Make the emulator notice the new settings. */
  1200.  
  1201.         XEmulatorMacroKeyFilter(XEM_IO,&XEM_MacroList);
  1202.     }
  1203. }
  1204.  
  1205.     /* HandleXEM():
  1206.      *
  1207.      *    Invokes the external emulation signal callback.
  1208.      */
  1209.  
  1210. VOID
  1211. HandleXEM()
  1212. {
  1213.     if(!XEmulatorSignal(XEM_IO,XEM_Signal))
  1214.     {
  1215.         CloseEmulator(FALSE);
  1216.  
  1217.         ResetDisplay = TRUE;
  1218.         ActivateJob(MainJobQueue,ResetDisplayJob);
  1219.     }
  1220. }
  1221.  
  1222.     /* HandleXEMJob(JobNode *UnusedJob):
  1223.      *
  1224.      *    Just makes a call to HandleXEM().
  1225.      */
  1226.  
  1227. BOOL
  1228. HandleXEMJob(JobNode *UnusedJob)
  1229. {
  1230.     HandleXEM();
  1231.  
  1232.     return(FALSE);
  1233. }
  1234.